package com.goodwill.androidtest;

import android.text.TextUtils;

import java.util.Deque;
import java.util.LinkedList;
import java.util.regex.Pattern;

import javax.xml.transform.Templates;

public class LogicUtil {
//    /**
//     * @author Carol
//     * 计算表达式
//     * 利用一个操作数栈和一个操作栈来进行计算
//     * 出栈情况：当前字符串为操作并且优先级小于栈顶操作元素或者遇到“)”，将操作栈中栈顶元素出栈，操作数栈中出栈俩元素
//     * 入栈情况：“(”直接入栈，或者当前操作优先级大于栈顶元素则直接入栈，操作数直接入栈
//     * @param expression
//     * @return
//     */
//    public static boolean parse2(String expression) {
//        Deque<String> operands = new LinkedList<>();//操作数栈
//        Deque<String> operate = new LinkedList<>();//操作栈
//        StringBuilder sb = new StringBuilder();
//        try {
//            byte[] bytes = expression.getBytes("GBK");
//            for (int i = 0 ; i < bytes.length ; i ++) {
//                //汉字
//                if (bytes[i] < 0) {
//                    if (i == bytes.length - 1) {//字符串异常截断
//                        //不要这个字
//                    } else {
//                        sb.append(new String(new byte[]{bytes[i], bytes[i + 1]}, "GBK"));
//                        i ++;
//                    }
//                    continue;
//                }
//                String thisOp = new String(new byte[]{bytes[i]});
//                //直接入栈
//                if ("(".equals(thisOp)) {
//                    pushOperandIntoStack(operands, sb);
//                    operate.addFirst(thisOp);
//                    continue;
//                }
//                //到“(”之前的全部出栈
//                if (")".equals(thisOp)) {
//                    pushOperandIntoStack(operands, sb);
//                    String topOp = operate.pollFirst();
//                    while(!"(".equals(topOp)){
//                        calculate(operands, topOp);
//                        if (operate.size() > 0) {
//                            topOp = operate.pollFirst();
//                        } else {
//                            //括号没匹配上，逻辑表达式出错
//                            return false;
//                        }
//
//                    }
//                    continue;
//                }
//                if (OperatorEnum.isOperator(thisOp)) {//当前是否为操作符
//                    //是，1.查看之前是否有字符未入栈，先入栈字符
//                    pushOperandIntoStack(operands, sb);
//                    //2.查看下一个是否为操作，并且非括号，是合并当前一起入操作栈
//                    String nextOp = new String(new byte[]{bytes[i + 1]});
//                    //下个与当前一起组成一个操作
//                    if (!"(".equals(nextOp) && !")".equals(nextOp) && OperatorEnum.isOperator(nextOp)) {
//                        thisOp += nextOp;
//                        i ++;
//                    }
//                    //判断当前操作与栈顶操作优先级
//                    if(operate.size() > 0){
//                        String topOp = operate.getFirst();
//                        while(!"(".equals(topOp) && OperatorEnum.getEnumByName(topOp).getPriority() < OperatorEnum.getEnumByName(thisOp).getPriority()){
//                            //优先级高，出栈进行计算
//                            topOp = operate.pollFirst();
//                            calculate(operands, topOp);
//                            if (operate.size() > 0) {
//                                topOp = operate.getFirst();
//                            } else {
//                                break;
//                            }
//
//                        }
//                    }
//                    operate.addFirst(thisOp);
//                } else {
//                    sb.append(thisOp);
//                }
//            }
//        } catch (Exception e){
//            e.printStackTrace();
//        }
//        if(sb.length() > 0){
//            operands.addFirst(sb.toString());
//        }
//        while(operate.size() > 0){
//            String topOp = operate.pollFirst();
//            calculate(operands, topOp);
//        }
//        if (operands.size() > 0){
//            String str = operands.pollFirst();
//            return StringUtils.isNotBlank(str) ? Boolean.parseBoolean(str) : false;
//        }
//        return false;
//    }
//
//    private static void pushOperandIntoStack(Deque operands, StringBuilder sb){
//        if(sb.length() > 0){
//            operands.addFirst(sb.toString());
//            sb.setLength(0);
//        }
//    }
//
//    private static void calculate(Deque<String> operands, String topOp){
//        String operand2 = operands.pollFirst().trim();
//        String operand1 = operands.pollFirst().trim();
//        //判断两个操作数类型，不一致不可比较直接返回false
//        OperandTypeEnum type1 = judgeType(operand1);
//        OperandTypeEnum type2 = judgeType(operand2);
//        if (type1 == type2) {
//            switch (type1){
//                case NUM:
//                    operands.addFirst(numCalculate(Long.parseLong(operand1), Long.parseLong(operand2),
//                            OperatorEnum.getEnumByName(topOp)) + "");
//                    break;
//                case DATE:
//                    operands.addFirst(dateCalculate(operand1, operand2, OperatorEnum.getEnumByName(topOp)) + "");
//                    break;
//                case STR:
//                    operands.addFirst(strCalculate(operand1, operand2, OperatorEnum.getEnumByName(topOp)) + "");
//                    break;
//            }
//        } else {
//            operands.addFirst("false");
//        }
//    }
//
//    private static OperandTypeEnum judgeType (String operands) {
//        operands = operands.trim();
//        if (Pattern.matches("^[-\\+]?[\\d]*$", operands)) {
//            return OperandTypeEnum.NUM;
//        }
////        if (DateUtil.verifyDateLegal(operands)) {
////            return OperandTypeEnum.DATE;
////        }
//        return OperandTypeEnum.STR;
//    }
//
//    private static boolean numCalculate(long operand1, long operand2, OperatorEnum operate){
//        switch (operate){
//            case LT:
//                return operand1 < operand2;
//            case ELT:
//                return operand1 <= operand2;
//            case GT:
//                return operand1 > operand2;
//            case EGT:
//                return operand1 >= operand2;
//            case EQ:
//                return operand1 == operand2;
//            case NEQ:
//                return operand1 != operand2;
//            default:
//                return true;
//        }
//    }
//
//    private static boolean strCalculate(String operand1, String operand2, OperatorEnum operate){
//        switch (operate){
//            case EQ:
//                return operand1.equals(operand2);
//            case NEQ:
//                return !operand1.equals(operand2);
//            case AND:
//                return "true".equals(operand1) && "true".equals(operand2);
//            case OR:
//                return "true".equals(operand1) || "true".equals(operand2);
//            default:
//                return true;
//        }
//    }
//
//    private static boolean dateCalculate(String operand1, String operand2, OperatorEnum operate){
//        switch (operate){
//            case LT:
//                return DateUtil.compareDate(operand1, operand2) == -1 ? true : false;
//            case ELT:
//                return DateUtil.compareDate(operand1, operand2) <= 0 ? true : false;
//            case GT:
//                return DateUtil.compareDate(operand1, operand2) == 1 ? true : false;
//            case EGT:
//                return DateUtil.compareDate(operand1, operand2) >= 0 ? true : false;
//            case EQ:
//                return DateUtil.compareDate(operand1, operand2) == 0 ? true : false;
//            case NEQ:
//                return DateUtil.compareDate(operand1, operand2) != 0 ? true : false;
//            default:
//                return true;
//        }
//    }

    public static boolean calculate(String expression, int score) {
//        if (TextUtils.isEmpty(expression))
            return false;
    }

    public boolean matchAND(String expression) {
        boolean isMatchAnd = false;
        if (expression.contains(OperatorEnum.AND.getName())) {
            String[] subArrays = expression.split(OperatorEnum.AND.getName());
            if (subArrays.length == 2) {
                String condition1 = subArrays[0];
                String condition2 = subArrays[1];
//                if (matchEGT(condition1) && matchLE(condition2)) {
//                    return true;
//                }
//
//                if (matchAND())
            }
        }

        return isMatchAnd;
    }

    public boolean matchEGT(String condition, int score) {
        boolean isMatch = false;
        if (TextUtils.isEmpty(condition)) return isMatch;
        if (condition.contains(OperatorEnum.EGT.getName())) {
            String[] values = condition.split(OperatorEnum.EGT.getName());
//            if (values.length == 2 && TextUtils.isEmpty(values[1].trim()) && ) {
//            }
        }

        return isMatch;
    }
}
